Collection of Tools & Utilities/Collection of Tools and Utilities.iso/asmutil/a86v400.zip/A07.DOC

Text File | 1994-12-21 | 21KB | 478 lines

CHAPTER 7   THE FLOATING-POINT PROCESSOR


In this chapter, we'll refer to the various Central Processing
Units (CPUs) as the "86".  Thus "86" refers to either the 8088,
8086, 80186, 80286, etc.  We'll refer to the various coprocessors
as the "87".  Thus "87" refers to either the 8087, the 287, the
387, or the special IIT-2C87 processor.


The 8087 and 287 Coprocessors

All IBM-PC's, and most clones, contain a socket for a floating
point coprocessor.  If you shell out between $70 and $200, and
plug the appropriate chip into that socket, then a host of
floating point instructions is added to the assembly language
instruction set.  The 486 DX series has the floating-point
processor built into the main CPU chip.

The original IBM-PC, and the XT, accept the original floating
point chip, the 8087.  Later processors accept corresponding
chips: the 287 for the 286, the 387 for the 386, etc.  From a
programming standpoint, the 8087 and 287 are nearly identical:
the 287 adds the instructions FSETPM and FSTSW AX, and ignores
the instructions FENI and FDISI.  There is, however, a rather
nasty design flaw in the 8087, that was corrected in the 287.

To understand the flaw, you must understand how the 86 and 87
work as coprocessors. Whenever the 86 sees a floating point
instruction, it communicates the instruction, and any associated
memory operands, to the 87.  Then the 86 goes on to its next
instruction, operating in parallel with the 87.  That's OK, so
long as the following instructions don't do one of the following:

  1. Execute another floating point instruction; or

  2. Try to read the results of the still-executing floating
     point instruction.

If they do, then you must provide an instruction called WAIT (or
synonymously FWAIT), which halts the 86 until the 87 is finished.
For almost all floating point instructions, it should not be
necessary to provide an explicit FWAIT; the 86 ought to know that
it should wait.  For the 8087, it IS necessary to give an
explicit FWAIT before each floating point instruction: that is
the flaw.

Because of the flaw, all assemblers supporting the 8087 will
silently insert an FWAIT code (hex 9B) before all 87
instructions, except those few (the FN instructions other than
FNOP) not requiring the FWAIT.  A86 will insert the opcode as
well, when it is assembling for the original 8087.
                                                              7-2

The are three ways to tell A86 whether it is assembling for an
8087 or a 287-or-later processor.  First, A86 will use a default
for the processor on which it is currently assembling: no .287
for an 8086, 8088, 186, or NEC; .287 for a 286 or later.  Second,
this can be overridden by the switch +F (the F must be
capitalized), to signal that the 287 is the target processor, or
-F to specify the 8087.  Third, an 8087 setting can be further
overridden in the source code, with the directive ".287",
compatible with Microsoft's assembler.

When A86 is assembling for the 287 or later, it ceases outputting
FWAIT directives that are unnecessary for the 287, ignores the
instructions FENI, FDISI, FNENI, and FNDISI, and honors the
instructions FSETPM and FSTSW AX.

WARNING: The most common mistake 87 programmers make is to try to
read the results of an 87 operation in 86 memory, before the
results are ready.  At least on my computer, the system often
crashes when you do this!  If your program runs correctly when
single stepped, but crashes when set loose, then chances are you
need an extra explicit FWAIT somewhere.


Extra Coprocessor Support

A86 now supports two additional coprocessors available for
PC-compatibles: the 80387, available for 386-based machines, and
the IIT-2C87, a 287-plug-compatible chip that adds a couple of
unique instructions. The IIT-2C87 has two extra banks of on-chip
8-number stacks, that can be switched in with the FBANK
instruction, and a matrix multiply instrction that uses all three
banks as input.  (For details contact Specialty Software
Development Corp., 110 Wild Basin Road, Austin TX 78746.) Both
chips incorporate the correction to the 8087's FWAIT design flaw,
so you can assemble with the .287 directive.  The extra
instructions for these chips are marked by "387 only:" and "IIT
only:" in the chart at the end of this chapter.


Emulating the 8087 by Software

There is a software package provided with many compilers
(Borland's Turbo C and most Microsoft compilers, for example)
that emulates the 8087 instruction set.  The emulator is very
cleverly implemented so that the programmer need not know whether
a floating point chip will be available, or whether emulation
will be necessary.  This is done by having the linker replace all
floating point machine instructions with INT calls to certain
interrupts, dedicated to emulation.  The interrupt handlers
interpret the operands to the instructions, and emulate the 8087.
                                                              7-3

You can tell A86 that the emulator might be used, by providing a
+f switch in the invocation line, or in the A86 environment
variable (make sure the f is lower case).  Since your program
will be linked to the emulator, you must be producing an OBJ
file, not a COM file, for emulation support to take effect.
Whenever a floating point instruction is assembled, A86 will
generate an external reference at the opcode for the instruction.
Then, if the emulation package is linked with your program, the
opcodes will be replaced by the INT calls. If a special
non-emulation module is linked, the opcodes will be left alone,
and the floating point instructions will be executed directly.

For the later processors (286 and beyond), emulation can be
provided that executes when the floating-point instructions
themselves are seen, so the +f games are not necessary.


The Floating Point Stack

The 87 has its own register set, of 8 floating point numbers
occupying 10 bytes each, plus 14 bytes of status and control
information.  Many of the 87's instructions cause the numbers to
act like a stack, much like a Hewlett-Packard calculator.  For
this reason, the numbers are called the floating point stack.

The standard name for the top element of the floating point stack
is either ST or ST(0); the others are named ST(1) through ST(7).
Thus, for example, the instruction to add stack element number 3
into the top stack element is usually coded FADD ST,ST(3).

I find this notation painfully verbose.  Especially bad are the
parentheses, which are hard to type, and which add visual clutter
to the program.  To alleviate this problem while retaining
language compatibility, I name my stack elements simply 0 through
7.  I recognize ST as a synonym for 0.  I allow expression
elements to be concatenated; concatenation is the same as
addition.  Thus, when A86 sees ST(3), it computes 0+3 = 3.  So
you can code the old way, FADD ST,ST(3), or you can code the
concise way, FADD 0,3 or simply FADD 3.


Floating Point Initializations

In general, you use the 87 by loading numbers from 86 memory to
the 87 stack (using FLD instructions), calculating on the 87
stack, and storing the results back to 86 memory (using FST and
FSTP instructions).  There are seven constant numbers built into
the 87 instruction set: zero, one, Pi, and four logarithmic
conversion constants.  These can be loaded using the FLD0, FLD1,
FLDPI, FLDL2T, FLDL2E, FLDLG2, and FLDLN2 instructions.  All
other constants must be declared in, then loaded from, 86 memory.
Integer constant words and doublewords can be loaded via FILD.
Non-integer constant doubleword, quadwords, and ten-byte numbers
can be loaded via FLD.
                                                              7-4

A86 allows you to declare constants loaded via FLD as floating
point numbers, using scientific notation if you like.  As an
exclusive feature, A86 allows you to use any of the 4 arithmetic
functions +, -, *, / in expressions involving floating point
numbers.  A86 will even do type conversion if one of the two
o